package com.edu.boot.controller;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.edu.boot.common.api.CommonResult;
import com.edu.boot.config.UserContext;
import com.edu.boot.entity.Recruitment;
import com.edu.boot.entity.SResume;
import com.edu.boot.entity.SResumeCopy;
import com.edu.boot.service.RecruitmentService;
import com.edu.boot.service.RecuritTypeService;
import com.edu.boot.service.SResumeCopyService;
import com.edu.boot.service.SResumeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 简历管理控制器
 * 处理简历相关的所有请求，包括简历的增删改查、收藏等功能
 */
@RestController
@RequestMapping("/resume")
public class SResumeController {
    
    @Autowired
    private SResumeService sResumeService;
    @Autowired
    private SResumeCopyService sResumeCopyService;
    @Autowired
    RecuritTypeService recuritTypeService;
    
    @Autowired
    RecruitmentService recruitmentService;

    /**
     * 添加新简历
     * @param resume 简历信息
     * @return 操作结果
     */
    @PostMapping("/add")
    public CommonResult addResume(@RequestBody SResume resume) {
        resume.setUId(UserContext.getUserId());
        resume.setCreateTime(DateUtil.date());
        sResumeService.addResume(resume);
        return CommonResult.success();
    }
    
    /**
     * 更新简历信息
     * @param resume 更新的简历信息
     * @return 操作结果
     */
    @PostMapping("/update")
    public CommonResult updateResume(@RequestBody SResume resume) {
        sResumeService.updateResume(resume);
        return CommonResult.success();
    }
    
    /**
     * 删除指定简历
     * @param tid 简历ID
     * @return 操作结果
     */
    @GetMapping("/delete/{tid}")
    public CommonResult deleteResume(@PathVariable Integer tid) {
        sResumeService.deleteResume(tid);
        return CommonResult.success();
    }
    
    /**
     * 根据ID获取简历详情
     * @param id 简历ID
     * @return 简历信息
     */
    @GetMapping("/getById/{id}")
    public CommonResult<SResume> getResumeById(@PathVariable Integer id) {
        SResume resume = sResumeService.getResumeById(id);
        return CommonResult.success(resume);
    }

    /**
     * 获取当前用户的简历信息
     * @return 当前用户的简历信息
     */
    @GetMapping("/get")
    public CommonResult<SResume> getResume() {
        // 构建查询条件：根据当前用户ID查询
        LambdaQueryWrapper<SResume> queryWrapper = new LambdaQueryWrapper<SResume>().eq(SResume::getUId, UserContext.getUserId());
        // 查询单条简历记录
        SResume resume = sResumeService.getOne(queryWrapper);
        return CommonResult.success(resume);
    }

    /**
     * 分页获取所有简历列表
     * @param current 当前页码
     * @param size 每页大小
     * @param recType 招聘类型（可选）
     * @return 分页简历列表
     */
    @GetMapping("/list")
    public CommonResult getAllResumes(@RequestParam(name = "currentpage") Integer current,
                                                     @RequestParam(name = "pagesize") Integer size,
                                                     @RequestParam(name = "recType",required = false) Integer recType) {
        Page<SResume> page = new Page<>(current, size);
        LambdaQueryWrapper<SResume> queryWrapper = new LambdaQueryWrapper<SResume>()
                .eq(Objects.nonNull(recType), SResume::getRecType, recType)
                .orderByDesc(SResume::getCreateTime);
        // 查询所有简历
        Page<SResume> resultPage = sResumeService.page(page, queryWrapper);
        if (CollectionUtil.isNotEmpty(resultPage.getRecords())){
            // 获取招聘类型的映射关系（ID -> 类型名称）
            Map<Integer, String> recuritTypeMap = recuritTypeService.getRecuritTypeMap();
            resultPage.getRecords().stream().forEach(resume -> {
                resume.setRecTypeMsg(recuritTypeMap.get(resume.getRecType()));
            });
        }
        return CommonResult.success(resultPage);
    }
    
    /**
     * 收藏简历
     * 将指定简历复制到收藏表中
     * @param id 要收藏的简历ID
     * @return 操作结果
     */
    @GetMapping("/collect/{id}")
    public CommonResult collectById(@PathVariable Integer id) {
        SResume resume = sResumeService.getResumeById(id);
        SResumeCopy sResumeCopy = new SResumeCopy();
        BeanUtil.copyProperties(resume, sResumeCopy);
        sResumeCopy.setQyId(UserContext.getUserId());
        LambdaQueryWrapper<SResumeCopy> copyLambda = new LambdaQueryWrapper<SResumeCopy>()
                .eq(SResumeCopy::getQyId, UserContext.getUserId())
                .eq(SResumeCopy::getUId, sResumeCopy.getUId());
        // 判断是否已经收藏过该简历
        int count = sResumeCopyService.count(copyLambda);
        if (count > 0){
            return CommonResult.failed("您已经收藏过该简历");
        }
        // 保存到收藏表中
        sResumeCopyService.save(sResumeCopy);
        return CommonResult.success();
    }
    
    /**
     * 取消收藏简历
     * @param id 要取消收藏的简历ID
     * @return 操作结果
     */
    @GetMapping("/cancelCollect/{id}")
    public CommonResult cancelCollectById(@PathVariable Integer id) {
        sResumeCopyService.removeById(id);
        return CommonResult.success();
    }
    
    /**
     * 获取推荐简历列表
     * 根据企业发布的招聘类型推荐相关简历
     * @param current 当前页码
     * @param size 每页大小
     * @param recType 招聘类型（可选）
     * @return 分页推荐简历列表
     */
    @GetMapping("/getGoodList")
    public CommonResult getGoodList(@RequestParam(name = "currentpage") Integer current,
                                      @RequestParam(name = "pagesize") Integer size,
                                      @RequestParam(name = "recType",required = false) Integer recType) {
        // 创建分页对象，设置当前页和每页大小
        Page<SResume> page = new Page<>(current, size);

        // 构建招聘信息查询条件：根据当前企业用户ID查询
        LambdaQueryWrapper<Recruitment> reLambda = new LambdaQueryWrapper<Recruitment>()
                .eq(Recruitment::getBId, UserContext.getUserId());
        // 查询该企业发布的所有招聘信息
        List<Recruitment> recruitmentList = recruitmentService.list(reLambda);

        // 初始化招聘类型列表
        List<Integer> recTypeList = Collections.emptyList();
        // 如果存在招聘信息，提取所有招聘类型
        if (CollectionUtil.isNotEmpty(recruitmentList)){
            recTypeList = recruitmentList.stream()
                    .map(item -> item.getRecType())
                    .collect(Collectors.toList());
        }

        // 构建简历查询条件：
        // 1. 如果指定了招聘类型，按指定类型筛选
        // 2. 如果企业有发布招聘，按企业发布的招聘类型筛选
        // 3. 按创建时间降序排序
        LambdaQueryWrapper<SResume> queryWrapper = new LambdaQueryWrapper<SResume>()
                .eq(Objects.nonNull(recType), SResume::getRecType, recType)
                .in(CollectionUtil.isNotEmpty(recTypeList), SResume::getRecType, recTypeList)
                .orderByDesc(SResume::getCreateTime);

        // 执行分页查询
        Page<SResume> resultPage = sResumeService.page(page, queryWrapper);

        // 如果查询结果不为空，为每条简历添加招聘类型说明
        if (CollectionUtil.isNotEmpty(resultPage.getRecords())){
            // 获取所有招聘类型映射
            Map<Integer, String> recuritTypeMap = recuritTypeService.getRecuritTypeMap();
            // 为每条简历设置招聘类型说明
            resultPage.getRecords().stream().forEach(resume -> {
                resume.setRecTypeMsg(recuritTypeMap.get(resume.getRecType()));
            });
        }

        return CommonResult.success(resultPage);
    }
    
    /**
     * 获取人才库中的收藏简历列表
     * 该方法用于分页获取企业用户收藏的简历信息
     *
     * @param current 当前页码，用于分页查询
     * @param size 每页显示的记录数量
     * @param recType 招聘类型ID（可选参数），用于按招聘类型筛选简历
     * @return CommonResult 包含分页后的收藏简历列表
     */
    @GetMapping("/collcetList")
    public CommonResult getCollectResumes(@RequestParam(name = "currentpage") Integer current,
                                      @RequestParam(name = "pagesize") Integer size,
                                      @RequestParam(name = "recType",required = false) Integer recType) {
        // 创建分页对象，设置当前页和每页大小
        Page<SResumeCopy> page = new Page<>(current, size);
        
        // 构建查询条件：
        // 1. 如果指定了招聘类型(recType不为null)，则按招聘类型筛选
        // 2. 按创建时间降序排序
        LambdaQueryWrapper<SResumeCopy> queryWrapper = new LambdaQueryWrapper<SResumeCopy>()
                .eq(Objects.nonNull(recType), SResumeCopy::getRecType, recType)
                .orderByDesc(SResumeCopy::getCreateTime);
        
        // 执行分页查询，获取收藏简历列表
        Page<SResumeCopy> resultPage = sResumeCopyService.page(page, queryWrapper);
        
        // 如果查询结果不为空，为每条简历添加招聘类型说明
        if (CollectionUtil.isNotEmpty(resultPage.getRecords())){
            // 获取所有招聘类型的映射关系（ID -> 类型名称）
            Map<Integer, String> recuritTypeMap = recuritTypeService.getRecuritTypeMap();
            // 遍历结果集，为每条简历设置招聘类型说明
            resultPage.getRecords().stream().forEach(resume -> {
                resume.setRecTypeMsg(recuritTypeMap.get(resume.getRecType()));
            });
        }
        
        // 返回查询结果
        return CommonResult.success(resultPage);
    }
}
